package magie;

import java.util.ArrayList;
import data.De;

public class Magie {

	private String classe;
	private int pourcCombattant;
	private int[] nbSortC = {0,0,0,0,0,0,0,0,0,0};
	private int[] nbSortU = {0,0,0,0,0,0,0,0,0,0};
	private int[] nbSortParjour = {-1,-1,-1,-1,-1,-1,-1,-1,-1,-1};
	
	private ArrayList<Sort> sortDeClasse;
	private ArrayList<Sort> sortDisponible;
	
	private boolean isInstinct = false;
	
	
	public Magie(Class<?> classe, int pourcCombattant) {		
		
		this.classe = classe.getSimpleName();
		this.pourcCombattant = pourcCombattant;
		this.sortDeClasse = new ArrayList<Sort>();
		this.sortDisponible = new ArrayList<Sort>();
		
		
		if ((this.classe.contains("Ensorceleur"))||(this.classe.contains("Barde")))
			this.isInstinct = true;
		
		
		InitSortDeClasse ();
	}
	
	private void InitSortDeClasse (){
		char InitialeClasse;
		int i;
		EListeSort[] liste = EListeSort.values();
		Sort sort;
				
		if(this.classe.contains("Paladin"))
			InitialeClasse = 'C';
		else if(this.classe.contains("Ensorceleur"))
			InitialeClasse = 'M';
		else
			InitialeClasse = this.classe.charAt(0);
		
		for(i=0 ; i<liste.length ; i++){
			if(liste[i].toString().charAt(0) == InitialeClasse){
				sort = new Sort(liste[i]);
				this.sortDeClasse.add(sort);
			}
		}
			
	}
		
	public void AddSort (int nbSort, int niveauSort){
		
		ArrayList<Sort> sortNiveauU = new ArrayList<Sort>();
		ArrayList<Sort> sortNiveauC = new ArrayList<Sort>();
		int nbTotalSortU = 0, i, nbTotalSortC = 0;
		int nbSortU, nbSortC, res;
		
		for (i=0; i<this.sortDeClasse.size(); i++){
			if(this.sortDeClasse.get(i).getNiveau()==niveauSort){
				if(this.sortDeClasse.get(i).isCombat()){
					sortNiveauC.add(this.sortDeClasse.get(i));
					nbTotalSortC ++;
				}
				else{
					sortNiveauU.add(this.sortDeClasse.get(i));
					nbTotalSortU ++;
				}
			}
		}
		
		//calcul du nombre de sort C et U
		nbSortC = (this.pourcCombattant * 
				(this.nbSortC[niveauSort]+this.nbSortU[niveauSort]+nbSort)) / 100;
		nbSortU = (this.nbSortC[niveauSort]+this.nbSortU[niveauSort]+nbSort) - nbSortC;
		if(this.isInstinct){
			if(nbSortC>nbTotalSortC){
				nbSortU += (nbSortC-nbTotalSortC);
				nbSortC = nbTotalSortC;
			}
			if(nbSortU>nbTotalSortU){
				nbSortC += (nbSortU-nbTotalSortU);
				nbSortU = nbTotalSortU;
			}
		}
		nbSortC = nbSortC - this.nbSortC[niveauSort];
		nbSortU = nbSortU - this.nbSortU[niveauSort];
		
		
		
		for (i=0 ; i<nbSortC ; i++){
			res = De.lancer(nbTotalSortC)-1;
			this.AddSort(sortNiveauC.get(res), sortNiveauC);
		}
		for (i=0 ; i<nbSortU ; i++){
			res = De.lancer(nbTotalSortU)-1;
			this.AddSort(sortNiveauU.get(res), sortNiveauU);
		}
		
		this.nbSortU[niveauSort] += nbSortU;
		this.nbSortC[niveauSort] += nbSortC;
		
	}
	
	private void AddSort (Sort sort, ArrayList<Sort> sortNiveau){
		int i;
		boolean exist = false;
		int sizeListeSort = sortNiveau.size(), res=0;
		
		
		for(i=0; i<this.sortDisponible.size(); i++){
			if(sort == this.sortDisponible.get(i)){
				exist = true;
				res = i;
			}
		}
		
		if(this.isInstinct){
			if(exist)
				this.AddSort(sortNiveau.get(De.lancer(sizeListeSort)-1), sortNiveau);
			else
				this.sortDisponible.add(sort);
		}
		else{
			if(exist)
				this.sortDisponible.get(res).setNbe(this.sortDisponible.get(res).getNbe()+1);
			else
				this.sortDisponible.add(sort);
		}
			
		
	}
	
	public void UpdateNbSortParJour (int[] nb){
		this.nbSortParjour = nb;
	}
	
	public int[] getNbSort (){
		int[] nbSort = new int[10];
		int i;
		
		for(i=0; i<10; i++)
			nbSort[i] = this.nbSortC[i] + this.nbSortU[i];
		return nbSort;
	}
	
	public int getMaxLvl(){
		int MaxLvl = -1;
		int i;
		for(i=0; i<10; i++){
			if(this.nbSortC[i]+this.nbSortU[i]==0)
				i = 10;
			else
				MaxLvl++;
		}
		return MaxLvl;
	}
	
	public void Tri(){
		Sort sortTemp;
		int i, j, decalage = 0;
		int[] nbSort = this.getNbSort();
		
		for(i=0; i<10; i++){
			if(nbSort[i]!=0){
				decalage = 0;
				for(j=0; j<this.sortDisponible.size(); j++){
					if(this.sortDisponible.get(j-decalage).getNiveau() == i){
						sortTemp = this.sortDisponible.get(j-decalage);
						this.sortDisponible.remove(j-decalage);
						this.sortDisponible.add(sortTemp);
						decalage++;
						if(decalage==nbSort[i])
							j=this.sortDisponible.size();
					}
				}
			}
		}
		
		
	}
	
 	public String toString () {
		int i, niveau = 0;
		String res = "sort disponible:" + this.classe + "\n";
		
		this.Tri();
		
		for(i=0; i<this.sortDisponible.size() ; i++){
			if(niveau==this.sortDisponible.get(i).getNiveau()){
				res += "Niveau " + niveau + ":";
				if(this.isInstinct){
					if(this.nbSortParjour[niveau]==-1)
						res += " (0 par jour)";
					else
						res += " (" + this.nbSortParjour[niveau] + " par jour)";
				}
				res+="\n";
				niveau++;
			}
			res += "  " + this.sortDisponible.get(i) + "\n";
		}
		
		return res;
	}
}
